home *** CD-ROM | disk | FTP | other *** search
/ APDL Eductation Resources / APDL Eductation Resources.iso / programs / graphics / gif2rpc / source / 8bpp / c / jjn < prev    next >
Encoding:
Text File  |  1995-10-16  |  5.5 KB  |  168 lines
  1. /* jjn.c
  2.  * AUTHOR:      Cy Booker, cy@cheepnis.demon.co.uk
  3.  * LICENSE:     FreeWare, Copyright (c) 1995 Cy Booker
  4.  *
  5.  * filter:              *  7  5
  6.  *                3  5  7  5  3
  7.  *                1  3  5  3  1         (1/48)
  8.  */
  9.  
  10. #include "internal.h"
  11.  
  12. #include <assert.h>
  13. #include <string.h>             /* memset() */
  14. #include <stdlib.h>             /* calloc() */
  15.  
  16. #include "OS:hourglass.h"
  17. #include "OS:macros.h"
  18.  
  19.  
  20.  
  21. /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  22.  */
  23.  
  24. extern bool process_gif_8bpp_jarvis_judice_ninke(
  25.                 const process_gif       *p) {
  26.   byte                  *rove;
  27.   int                   width, height;
  28.   int                   x, y;
  29.   const os_colour       *palette;
  30.   int                   line_length;
  31.   int                   *buffer, *this_row, *next_row, *botm_row;
  32.   int                   buffer_width;
  33.   int                   red, grn, blu;
  34.   os_colour             colour;
  35.   int                   error_red, error_grn, error_blu;
  36.   int                   temp_red, temp_grn, temp_blu;
  37.   rgbtupleout           error;
  38.   rgbtupleout_fn        fn;
  39.  
  40.   assert(p);
  41.   assert(p->pixel_width > 0);
  42.   assert(p->pixel_height > 0);
  43.   assert(p->in_palette.colours);
  44.   assert(p->fn);
  45.  
  46.   /*
  47.    * jarvis_judice_ninke requires storing error info for two pixels to right and two pixels to left
  48.    * so we will just allocate two extra columns for each row and not do any edge checks
  49.    * each entry is stored as {r*SCALE, g*SCALE, b*SCALE}
  50.    */
  51.   buffer_width = (2 + p->pixel_width + 2) * 3;
  52.   buffer = calloc(1, sizeof(*buffer) * (buffer_width * 3));
  53.   if (!buffer) {
  54.     /*
  55.      * oh dear
  56.      */
  57.     return TRUE;
  58.   }
  59.  
  60.   error.palette = p->out_palette;               /* structure copy */
  61.   /*
  62.    * not we pre-load values from the process_gif array
  63.    * because it considerably helps the compiler produce better code
  64.    */
  65.   rove = p->buffer;
  66.   width = p->pixel_width;
  67.   height = p->pixel_height;
  68.   palette = p->in_palette.colours;
  69.   line_length = p->line_length;
  70.   fn = p->fn;
  71.   for (y= height; (y > 0); y--) {
  72.     if ((y & 7) == 0) {
  73.       xhourglass_percentage((y * 100) / height);
  74.     }
  75.     this_row = buffer + (buffer_width * ((y + 3) % 3)) + 2*3;
  76.     next_row = buffer + (buffer_width * ((y + 2) % 3)) + 2*3;
  77.     botm_row = buffer + (buffer_width * ((y + 1) % 3)) + 2*3;
  78.     /* bottom row has no errors */
  79.     memset(botm_row, 0, sizeof(*botm_row) * (buffer_width - 2*3));
  80.     /*
  81.      * note that just because we are actually scanning/outputting right to left
  82.      * doesn't matter as far as jarvis_judice_ninke is concerned
  83.      * although it might help if we could ``snake''
  84.      */
  85.     for (x= width - 1; (x >= 0); x--) {
  86.       INPUT;
  87.  
  88.       red += *this_row++;                               /* add in errors from all rows */
  89.       grn += *this_row++;
  90.       blu += *this_row++;
  91.  
  92.       PROCESS;
  93.  
  94.       temp_red = (red * 7) / 48; error_red = red - (2 * temp_red);
  95.       temp_grn = (grn * 7) / 48; error_grn = grn - (2 * temp_grn);
  96.       temp_blu = (blu * 7) / 48; error_blu = blu - (2 * temp_blu);
  97.       this_row[ 0] += temp_red;                         /* this[ 1] += 7/48 */
  98.       this_row[ 1] += temp_grn;
  99.       this_row[ 2] += temp_blu;
  100.  
  101.       next_row[ 0] += temp_red;                         /* next[ 0] += 7/48 */
  102.       next_row[ 1] += temp_grn;
  103.       next_row[ 2] += temp_blu;
  104.  
  105.       temp_red = (red * 5) / 48; error_red -= 4 * temp_red;
  106.       temp_grn = (grn * 5) / 48; error_grn -= 4 * temp_grn;
  107.       temp_blu = (blu * 5) / 48; error_blu -= 4 * temp_blu;
  108.  
  109.       this_row[ 3] += temp_red;                         /* this[ 2] += 5/48 */
  110.       this_row[ 4] += temp_grn;
  111.       this_row[ 5] += temp_blu;
  112.  
  113.       next_row[ 3] += temp_red;                         /* next[ 1] += 5/48 */
  114.       next_row[ 4] += temp_grn;
  115.       next_row[ 5] += temp_blu;
  116.  
  117.       next_row[-3] += temp_red;                         /* next[-1] += 5/48 */
  118.       next_row[-2] += temp_grn;
  119.       next_row[-1] += temp_blu;
  120.  
  121.       botm_row[ 0] += temp_red;                         /* botm[ 0] += 5/48 */
  122.       botm_row[ 1] += temp_grn;
  123.       botm_row[ 2] += temp_blu;
  124.  
  125.       temp_red = (red * 3) / 48; error_red -= 4 * temp_red;
  126.       temp_grn = (grn * 3) / 48; error_grn -= 4 * temp_grn;
  127.       temp_blu = (blu * 3) / 48; error_blu -= 4 * temp_blu;
  128.  
  129.       next_row[ 6] += temp_red;                         /* next[ 2] += 3/48 */
  130.       next_row[ 7] += temp_grn;
  131.       next_row[ 8] += temp_blu;
  132.  
  133.       next_row[-6] += temp_red;                         /* next[-2] += 3/48 */
  134.       next_row[-5] += temp_grn;
  135.       next_row[-4] += temp_blu;
  136.  
  137.       botm_row[ 3] += temp_red;                         /* botm[ 1] += 3/48 */
  138.       botm_row[ 4] += temp_grn;
  139.       botm_row[ 5] += temp_blu;
  140.  
  141.       botm_row[-3] += temp_red;                         /* botm[-1] += 3/48 */
  142.       botm_row[-2] += temp_grn;
  143.       botm_row[-1] += temp_blu;
  144.  
  145.       temp_red = (red * 1) / 48; error_red -= temp_red;
  146.       temp_grn = (grn * 1) / 48; error_grn -= temp_grn;
  147.       temp_blu = (blu * 1) / 48; error_blu -= temp_blu;
  148.  
  149.       botm_row[-6] += temp_red;                         /* botm[-2] += 1/48 */
  150.       botm_row[-5] += temp_grn;
  151.       botm_row[-4] += temp_blu;
  152.  
  153.       botm_row[ 6] += error_red;                        /* botm[ 2] += 1/48 */
  154.       botm_row[ 7] += error_grn;
  155.       botm_row[ 8] += error_blu;
  156.  
  157.       next_row += 3;                                    /* adjust next_row pointer */
  158.       botm_row += 3;                                    /* adjust botm_row pointer */
  159.  
  160.     }
  161.     rove += line_length;
  162.   }
  163.   free(buffer);
  164.   return FALSE;
  165. }
  166.  
  167.  
  168.